/**
 * Created by Administrator on 2016/1/7.
 */

/* canvas-toBlob.js
 * A canvas.toBlob() implementation.
 * 2011-07-13
 *
 * By Eli Grey, http://eligrey.com and Devin Samarin, https://github.com/eboyjr
 * License: X11/MIT
 *   See LICENSE.md
 */

/*global self */
/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
 plusplus: true */

/*! @source http://purl.eligrey.com/github/canvas-toBlob.js/blob/master/canvas-toBlob.js */

(function(view) {
    "use strict";
    var
        Uint8Array = view.Uint8Array
        , HTMLCanvasElement = view.HTMLCanvasElement
        , is_base64_regex = /\s*;\s*base64\s*(?:;|$)/i
        , base64_ranks
        , decode_base64 = function(base64) {
            var
                len = base64.length
                , buffer = new Uint8Array(len / 4 * 3 | 0)
                , i = 0
                , outptr = 0
                , last = [0, 0]
                , state = 0
                , save = 0
                , rank
                , code
                , undef
                ;
            while (len--) {
                code = base64.charCodeAt(i++);
                rank = base64_ranks[code-43];
                if (rank !== 255 && rank !== undef) {
                    last[1] = last[0];
                    last[0] = code;
                    save = (save << 6) | rank;
                    state++;
                    if (state === 4) {
                        buffer[outptr++] = save >>> 16;
                        if (last[1] !== 61 /* padding character */) {
                            buffer[outptr++] = save >>> 8;
                        }
                        if (last[0] !== 61 /* padding character */) {
                            buffer[outptr++] = save;
                        }
                        state = 0;
                    }
                }
            }
            // 2/3 chance there's going to be some null bytes at the end, but that
            // doesn't really matter with most image formats.
            // If it somehow matters for you, truncate the buffer up outptr.
            return buffer.buffer;
        }
        ;
    if (Uint8Array) {
        base64_ranks = new Uint8Array([
            62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1
            , -1, -1,  0, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9
            , 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25
            , -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35
            , 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
        ]);
    }
    if (HTMLCanvasElement && !HTMLCanvasElement.prototype.toBlob) {
        HTMLCanvasElement.prototype.toBlob = function(callback, type /*, ...args*/) {
            if (!type) {
                type = "image/png";
            } if (this.mozGetAsFile) {
                callback(this.mozGetAsFile("canvas", type));
                return;
            }
            var
                args = Array.prototype.slice.call(arguments, 1)
                , dataURI = this.toDataURL.apply(this, args)
                , header_end = dataURI.indexOf(",")
                , data = dataURI.substring(header_end + 1)
                , is_base64 = is_base64_regex.test(dataURI.substring(0, header_end))
                , blob
                ;
            if (Blob.fake) {
                // no reason to decode a data: URI that's just going to become a data URI again
                blob = new Blob
                if (is_base64) {
                    blob.encoding = "base64";
                } else {
                    blob.encoding = "URI";
                }
                blob.data = data;
                blob.size = data.length;
            } else if (Uint8Array) {
                if (is_base64) {
                    blob = new Blob([decode_base64(data)], {type: type});
                } else {
                    blob = new Blob([decodeURIComponent(data)], {type: type});
                }
            }
            callback(blob);
        };
    }
}(self));